home *** CD-ROM | disk | FTP | other *** search
/ Greenhouse Effect Detection Expriment / NASA Greenhouse Effect Detection Expriment 1992 - Disc 2.iso / software / dos / cdf22pc / src / tools / cdfdump.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-04  |  20.6 KB  |  729 lines
  1. /******************************************************************************
  2. *
  3. *  NSSDC/CDF            CDFdump - dump all records found in .CDF file.
  4. *
  5. *  Version 2.0, 4-Mar-92, ST Systems (STX)
  6. *
  7. *  Modification history:
  8. *
  9. *   V1.0  29-May-91, J Love    Original version.
  10. *   V1.1  25-Jun-91, J Love    Moved increment.  Display fill value.  Display
  11. *                extend records.  CDF_EPOCH added as a data
  12. *                type.  Added QOP.  Added PageInst.
  13. *   V1.2  26-Jul-91, J Love    Added SEEK_CUR.  Added XDR decoding.
  14. *                Use 'Exit'/'ExitBAD'.
  15. *   V1.3   7-Oct-91, J Love    Modified for IBM-PC port (and IBM-RS6000).
  16. *   V2.0   4-Mar-92, J Love    IBM PC port/CDF V2.2.
  17. *
  18. ******************************************************************************/
  19.  
  20. #include "cdflib.h"
  21. #include "cdfdump.h"
  22.  
  23. /******************************************************************************
  24. * Global variables.
  25. ******************************************************************************/
  26.  
  27. static long usedBytes = 0;
  28. static long wastedBytes = 0;
  29. static long GDRcount = 0;
  30. static long CDRcount = 0;
  31. static long ADRcount = 0;
  32. static long AEDRcount = 0;
  33. static long VDRcount = 0;
  34. static long VXRcount = 0;
  35. static long VVRcount = 0;
  36. static long UNUSEDcount = 0;
  37.  
  38. /******************************************************************************
  39. * MAIN.
  40. ******************************************************************************/
  41.  
  42. #if defined(vms)
  43. main (argc, argv)
  44. #else
  45. main (argc, argv)
  46. #endif
  47. int argc;
  48. char *argv[];
  49. {
  50. File *CDFfp;
  51. FILE *OUTfp;
  52. char CDFpath[CDF_FILE_NAME_LEN + 1];
  53. char oSpec[MAX_PATH_LEN+1];
  54. char oDir[MAX_DIR_LEN+1];
  55. char oName[MAX_NAME_LEN+1];
  56. long int4;
  57. char docText[CDF_DOCUMENT_LEN + 1];
  58. long recordSize;
  59. long recordType;
  60. long offset;
  61. long numDims;
  62. long encoding;
  63. long i;
  64. long VarFlags;
  65. long nBytes;
  66. long numElements;
  67. long dataType;
  68. long *firstRec;
  69. long *lastRec;
  70. long *VVRoffset;
  71. long Nentries;
  72. void *fillValue;
  73. char attrName[CDF_ATTR_NAME_LEN + 1];
  74. char varName[CDF_VAR_NAME_LEN + 1];
  75. char REFvarFileName[CDF_FILE_NAME_LEN + 1];
  76. void *ptr;
  77. void *valuePtr;
  78. char string[80+1];
  79. char string1[80+1];
  80. struct EPOCH ep;
  81. enum { BRIEF_, FULL_ } level;
  82. int count;
  83.  
  84. QOP *qop;
  85. static char *validQuals[] = { "output", "brief", "full", NULL };
  86. static int optRequired[] = { TRUE, FALSE, FALSE, 0 };
  87.  
  88. #if defined(vms)
  89. static char *instructions[] = {
  90. "Usage:    CDFDUMP [/OUTPUT=<output-file>] [/BRIEF or /FULL] <cdf-name>",
  91. NULL };
  92. #endif
  93.                     
  94. #if defined(unix) | defined(__MSDOS__)
  95. static char *instructions[] = {
  96. "Usage:    cdfdump [-output <output-file>] [-brief or -full] <cdf-name>",
  97. NULL };
  98. #endif
  99.  
  100. /******************************************************************************
  101. * Determine qualifiers/options/parameters.
  102. ******************************************************************************/
  103.  
  104. switch (argc == 1) {
  105.   case 1:
  106.     PageInst (instructions);
  107.     Exit;
  108.   default:
  109.     qop = Qop (argc, argv, validQuals, optRequired);
  110.     if (qop == NULL) ExitBAD;
  111.  
  112.     if (qop->Nparms < 1) {
  113.       printf ("Missing parameter.\n");
  114.       ExitBAD;
  115.     }
  116.     else {
  117.       strcpy (CDFpath, qop->parms[0]);
  118.       if (strstr(CDFpath,".cdf") == NULL && strstr(CDFpath,".CDF") == NULL)
  119.         strcat(CDFpath,".cdf");
  120. #if VIO_FOR_STREAM
  121.         CDFfp = Open (CDFpath, "rb", 1);  /* only 1 buffer, sequential reads */
  122. #else
  123.         CDFfp = Open (CDFpath, "rb");
  124. #endif
  125.       if (CDFfp == NULL) {
  126.     printf ("Error opening CDF.\n");
  127.     ExitBAD;
  128.       }
  129.     }
  130.  
  131.     if (qop->qualEntered[0]) {
  132.       strcpy (oSpec, qop->qualOpt[0]);
  133.       ParsePath (oSpec, oDir, oName);
  134.       if (strchr(oName,'.') == NULL) strcat (oSpec, ".dmp");
  135.       OUTfp = fopen (oSpec, "w");
  136.       if (OUTfp == NULL) {
  137.     printf ("Unable to open output file (%s).\n", oSpec);
  138.     ExitBAD;
  139.       }
  140.     }
  141.     else
  142.       OUTfp = stdout;
  143.  
  144.     count = 0;
  145.     if (qop->qualEntered[1]) count++;
  146.     if (qop->qualEntered[2]) count++;
  147.  
  148.     switch (count) {
  149.       case 0:
  150.     level = BRIEF_;
  151.     break;
  152.       case 1:
  153.     if (qop->qualEntered[1])
  154.       level = BRIEF_;
  155.     else
  156.       level = FULL_;
  157.     break;
  158.       default:
  159.     printf ("Conflicting qualifiers.\n");
  160.     ExitBAD;
  161.     }
  162.  
  163.     break;
  164. }
  165.  
  166. /******************************************************************************
  167. * Dump magic number(s).
  168. ******************************************************************************/
  169.  
  170. getint32 (CDFfp, int4);
  171. if (level == FULL_) fprintf (OUTfp, "Magic number (1): %8lX (hex)\n", int4);
  172.  
  173. getint32 (CDFfp, int4);
  174. if (level == FULL_) fprintf (OUTfp, "Magic number (2): %8lX (hex)\n", int4);
  175.  
  176. usedBytes += 8;
  177.  
  178. /******************************************************************************
  179. * Read and dump records until EOF (or illegal record) reached.
  180. ******************************************************************************/
  181.  
  182. for (;;) {
  183.    /***************************************************************************
  184.    * record size
  185.    ***************************************************************************/
  186.  
  187.    offset = Tell (CDFfp);
  188.  
  189.    recordSize = 0;            /* Just in case. */
  190.  
  191.    getint32 (CDFfp, recordSize);
  192.    if (Eof(CDFfp)) {
  193.      DisplayStats (OUTfp);
  194.      Exit;
  195.    }
  196.  
  197.    if (recordSize <= 0) {
  198.      DisplayStats (OUTfp);
  199.      Exit;
  200.    }
  201.  
  202.    if (level == FULL_)
  203.      fprintf (OUTfp, "\nRecord size: %ld   (at byte offset %ld)\n",
  204.           recordSize, offset);
  205.  
  206.    /***************************************************************************
  207.    * record type
  208.    ***************************************************************************/
  209.  
  210.    getint32 (CDFfp, recordType);
  211.    if (level == FULL_) fprintf (OUTfp, "Record type: %ld ", recordType);
  212.  
  213.    if (level == FULL_)
  214.      switch (recordType) {
  215.        case CDR_: fprintf (OUTfp, "(CDR)\n"); break;
  216.        case GDR_: fprintf (OUTfp, "(GDR)\n"); break;
  217.        case VDR_: fprintf (OUTfp, "(VDR)\n"); break;
  218.        case VXR_: fprintf (OUTfp, "(VXR)\n"); break;
  219.        case VVR_: fprintf (OUTfp, "(VVR)\n"); break;
  220.        case ADR_: fprintf (OUTfp, "(ADR)\n"); break;
  221.        case AEDR_: fprintf (OUTfp, "(AEDR)\n"); break;
  222.        case UNUSED_: fprintf (OUTfp, "(UNUSED)\n"); break;
  223.        default: fprintf (OUTfp, "(Unknown: %ld\n", recordType);
  224.      }
  225.  
  226.    switch (recordType) {
  227.       /************************************************************************
  228.       * Unused record
  229.       ************************************************************************/
  230.  
  231.       case UNUSED_:
  232.        UNUSEDcount++;
  233.  
  234.        nBytes = recordSize - 8;
  235.  
  236.        ptr = (void *) malloc (nBytes);
  237.        CHECKmalloc (ptr);
  238.        Read (ptr, nBytes, 1, CDFfp);
  239.        free (ptr);
  240.  
  241.        wastedBytes += recordSize;
  242.        break;
  243.  
  244.       /************************************************************************
  245.       * CDF descriptor record
  246.       ************************************************************************/
  247.  
  248.       case CDR_:
  249.        CDRcount++;
  250.  
  251.        getint32 (CDFfp, int4);
  252.        if (level == FULL_) fprintf (OUTfp, "GDRoffset: %ld\n", int4);
  253.  
  254.        getint32 (CDFfp, int4);
  255.        if (level == FULL_) fprintf (OUTfp, "version: %ld\n", int4);
  256.  
  257.        getint32 (CDFfp, int4);
  258.        if (level == FULL_) fprintf (OUTfp, "release: %ld\n", int4);
  259.  
  260.        getint32 (CDFfp, encoding);
  261.        if (level == FULL_) fprintf (OUTfp, "encoding: %ld\n", encoding);
  262.  
  263.        getint32 (CDFfp, int4);
  264.        if (level == FULL_) fprintf (OUTfp, "CDFflags: %ld\n", int4);
  265.  
  266.        getint32 (CDFfp, int4);
  267.        if (level == FULL_) fprintf (OUTfp, "rfuA: %ld\n", int4);
  268.  
  269.        getint32 (CDFfp, int4);
  270.        if (level == FULL_) fprintf (OUTfp, "rfuB: %ld\n", int4);
  271.  
  272.        getint32 (CDFfp, int4);
  273.        if (level == FULL_) fprintf (OUTfp, "increment: %ld\n", int4);
  274.  
  275.        getint32 (CDFfp, int4);
  276.        if (level == FULL_) fprintf (OUTfp, "rfuD: %ld\n", int4);
  277.  
  278.        getint32 (CDFfp, int4);
  279.        if (level == FULL_) fprintf (OUTfp, "rfuE: %ld\n", int4);
  280.  
  281.        Read (docText, CDF_DOCUMENT_LEN, 1, CDFfp);
  282.        if (level == FULL_) fprintf (OUTfp, "copyright follows...\n%s\n",
  283.                     docText);
  284.  
  285.        usedBytes += recordSize;
  286.        break;
  287.  
  288.       /************************************************************************
  289.       * Global descriptor record
  290.       ************************************************************************/
  291.  
  292.       case GDR_:
  293.        GDRcount++;
  294.  
  295.        getint32 (CDFfp, int4);
  296.        if (level == FULL_) fprintf (OUTfp, "VDRhead: %ld\n", int4);
  297.  
  298.        getint32 (CDFfp, int4);
  299.        if (level == FULL_) fprintf (OUTfp, "garbage1: %ld\n", int4);
  300.  
  301.        getint32 (CDFfp, int4);
  302.        if (level == FULL_) fprintf (OUTfp, "ADRhead: %ld\n", int4);
  303.  
  304.        getint32 (CDFfp, int4);
  305.        if (level == FULL_) fprintf (OUTfp, "Eof: %ld\n", int4);
  306.  
  307.        getint32 (CDFfp, int4);
  308.        if (level == FULL_) fprintf (OUTfp, "numVar: %ld\n", int4);
  309.  
  310.        getint32 (CDFfp, int4);
  311.        if (level == FULL_) fprintf (OUTfp, "numAttr: %ld\n", int4);
  312.  
  313.        getint32 (CDFfp, int4);
  314.        if (level == FULL_) fprintf (OUTfp, "maxRec: %ld\n", int4);
  315.  
  316.        getint32 (CDFfp, numDims);
  317.        if (level == FULL_) fprintf (OUTfp, "numDims: %ld\n", numDims);
  318.  
  319.        getint32 (CDFfp, int4);
  320.        if (level == FULL_) fprintf (OUTfp, "rfuA: %ld\n", int4);
  321.  
  322.        getint32 (CDFfp, int4);
  323.        if (level == FULL_) fprintf (OUTfp, "rfuB: %ld\n", int4);
  324.  
  325.        getint32 (CDFfp, int4);
  326.        if (level == FULL_) fprintf (OUTfp, "rfuD: %ld\n", int4);
  327.  
  328.        getint32 (CDFfp, int4);
  329.        if (level == FULL_) fprintf (OUTfp, "rfuD: %ld\n", int4);
  330.  
  331.        getint32 (CDFfp, int4);
  332.        if (level == FULL_) fprintf (OUTfp, "rfuE: %ld\n", int4);
  333.  
  334.        for (i = 0; i < numDims; i++) {
  335.           getint32 (CDFfp, int4);
  336.           if (level == FULL_) fprintf (OUTfp, " dimSize[%ld]: %ld\n",
  337.                        i, int4);
  338.        }
  339.  
  340.        usedBytes += recordSize;
  341.        break;
  342.  
  343.       /************************************************************************
  344.       * Variable descriptor record
  345.       ************************************************************************/
  346.  
  347.       case VDR_:
  348.        VDRcount++;
  349.  
  350.        getint32 (CDFfp, int4);
  351.        if (level == FULL_) fprintf (OUTfp, "VDRnext: %ld\n", int4);
  352.  
  353.        getint32 (CDFfp, dataType);
  354.        if (level == FULL_) fprintf (OUTfp, "dataType: %ld\n", dataType);
  355.  
  356.        getint32 (CDFfp, int4);
  357.        if (level == FULL_) fprintf (OUTfp, "varMaxRec: %ld\n", int4);
  358.  
  359.        getint32 (CDFfp, int4);
  360.        if (level == FULL_) fprintf (OUTfp, "VXRhead: %ld\n", int4);
  361.  
  362.        getint32 (CDFfp, int4);
  363.        if (level == FULL_) fprintf (OUTfp, "VXRtail: %ld\n", int4);
  364.  
  365.        getint32 (CDFfp, VarFlags);
  366.        if (level == FULL_) fprintf (OUTfp, "VARflags: %ld\n", VarFlags);
  367.  
  368.        getint32 (CDFfp, int4);
  369.        if (level == FULL_) fprintf (OUTfp, "rfuA: %ld\n", int4);
  370.  
  371.        getint32 (CDFfp, int4);
  372.        if (level == FULL_) fprintf (OUTfp, "rfuB: %ld\n", int4);
  373.  
  374.        getint32 (CDFfp, int4);
  375.        if (level == FULL_) fprintf (OUTfp, "rfuC: %ld\n", int4);
  376.  
  377.        getint32 (CDFfp, int4);
  378.        if (level == FULL_) fprintf (OUTfp, "REFvarNum: %ld\n", int4);
  379.  
  380.        Read (REFvarFileName, CDF_FILE_NAME_LEN, 1, CDFfp);
  381.        if (level == FULL_) fprintf (OUTfp, "REFfileName: %s\n",
  382.                     REFvarFileName);
  383.  
  384.        getint32 (CDFfp, numElements);
  385.        if (level == FULL_) fprintf (OUTfp, "numElements: %ld\n",
  386.                     numElements);
  387.  
  388.        getint32 (CDFfp, int4);
  389.        if (level == FULL_) fprintf (OUTfp, "varNum: %ld\n", int4);
  390.  
  391.        getint32 (CDFfp, int4);
  392.        if (level == FULL_) fprintf (OUTfp, "rfuD: %ld\n", int4);
  393.  
  394.        getint32 (CDFfp, int4);
  395.        if (level == FULL_) fprintf (OUTfp, "extend records: %ld\n", int4);
  396.  
  397.        Read (varName, CDF_VAR_NAME_LEN, 1, CDFfp);
  398.        if (level == FULL_) fprintf (OUTfp, "varName: %s\n", varName);
  399.  
  400.         for (i = 0; i < numDims; i++) {
  401.           getint32 (CDFfp, int4);
  402.           if (level == FULL_) fprintf (OUTfp, " dimVary[%ld]: %ld\n",
  403.                        i, int4);
  404.        }
  405.  
  406.        if (bitset(VarFlags,VAR_FILLVALUE_BIT)) {
  407.          nBytes = ElemSize(dataType) * numElements;
  408.          fillValue = (void *) malloc (nBytes);
  409.          CHECKmalloc (fillValue);
  410.          Read (fillValue, nBytes, 1, CDFfp);
  411.  
  412.          DecodeBuffer (encoding, dataType, numElements, fillValue);
  413.  
  414.          strcpy (string, "Fill value: ");
  415.  
  416.          if (dataType == CDF_CHAR || dataType == CDF_UCHAR)
  417.            strcat (string, "\"");
  418.  
  419.          for (i = 0; i < numElements; i++) {
  420.             switch (dataType) {
  421.           case CDF_INT1:
  422.           case CDF_BYTE:
  423.               sprintf (string1, "%d ",
  424.                    *((Schar *) fillValue + i));
  425.               break;
  426.           case CDF_UINT1:
  427.               sprintf (string1, "%u ",
  428.                    *((Uchar *) fillValue + i));
  429.               break;
  430.           case CDF_CHAR:
  431.           case CDF_UCHAR:
  432.               sprintf (string1, "%c", *((char *) fillValue + i));
  433.               break;
  434.           case CDF_INT2:
  435.               sprintf (string1, "%d ", *((short *) fillValue + i));
  436.               break;
  437.           case CDF_UINT2:
  438.               sprintf (string1, "%u ",
  439.                    *((unsigned short *) fillValue + i));
  440.               break;
  441.           case CDF_INT4:
  442.               sprintf (string1, "%ld ", *((long *) fillValue + i));
  443.               break;
  444.           case CDF_UINT4:
  445.               sprintf (string1, "%lu ",
  446.                    *((unsigned long *) fillValue + i));
  447.               break;
  448.           case CDF_REAL4:
  449.           case CDF_FLOAT:
  450.               sprintf (string1, "%f ", *((float *) fillValue + i));
  451.               break;
  452.           case CDF_REAL8:
  453.           case CDF_DOUBLE:
  454.               sprintf (string1, "%f ", *((double *) fillValue + i));
  455.               break;
  456.           case CDF_EPOCH:
  457.               ep.tSince0 = *((double *) fillValue + i);
  458.               strcpy (string1, epochString(&ep));
  459.               strcat (string1, " ");
  460.               break;
  461.           default:
  462.               strcpy (string1, "?");
  463.               break;
  464.             }
  465.  
  466.             if (strlen(string) + strlen(string1) > 75) {
  467.           strcat (string, "...");
  468.           break;
  469.             }
  470.             else
  471.           strcat (string, string1);
  472.          }
  473.  
  474.          if (dataType == CDF_CHAR ||
  475.          dataType == CDF_UCHAR) strcat (string, "\"");
  476.          if (level == FULL_) fprintf (OUTfp, "%s\n", string);
  477.        }
  478.  
  479.        usedBytes += recordSize;
  480.        break;
  481.  
  482.       /************************************************************************
  483.       * Variable Index record
  484.       ************************************************************************/
  485.  
  486.       case VXR_:
  487.        VXRcount++;
  488.  
  489.        getint32 (CDFfp, int4);
  490.        if (level == FULL_) fprintf (OUTfp, "VXRnext: %ld\n", int4);
  491.  
  492.        getint32 (CDFfp, Nentries);
  493.        if (level == FULL_) fprintf (OUTfp, "Nentries: %ld\n", Nentries);
  494.  
  495.        getint32 (CDFfp, int4);
  496.        if (level == FULL_) fprintf (OUTfp, "NusedEntries: %ld\n", int4);
  497.  
  498.        firstRec = (long *) malloc (Nentries * sizeof(long));
  499.        CHECKmalloc (firstRec);
  500.        lastRec = (long *) malloc (Nentries * sizeof(long));
  501.        CHECKmalloc (lastRec);
  502.        VVRoffset = (long *) malloc (Nentries * sizeof(long));
  503.        CHECKmalloc (VVRoffset);
  504.  
  505.        for (i = 0; i < Nentries; i++) getint32 (CDFfp, firstRec[i]);
  506.        for (i = 0; i < Nentries; i++) getint32 (CDFfp, lastRec[i]);
  507.        for (i = 0; i < Nentries; i++) getint32 (CDFfp, VVRoffset[i]);
  508.  
  509.        if (level == FULL_)
  510.          fprintf (OUTfp, "\n  Entry  FirstRec  LastRec  VVRoffset\n");
  511.        for (i = 0; i < Nentries; i++)
  512.           if (level == FULL_)
  513.         fprintf (OUTfp, "   %2ld    %5ld    %5ld     %9ld\n",
  514.                  i, firstRec[i], lastRec[i], VVRoffset[i]);
  515.  
  516.        free (firstRec);
  517.        free (lastRec);
  518.        free (VVRoffset);
  519.  
  520.        usedBytes += recordSize;
  521.        break;
  522.  
  523.       /************************************************************************
  524.       * Variable Values record
  525.       ************************************************************************/
  526.  
  527.       case VVR_:
  528.        VVRcount++;
  529.  
  530.        Seek (CDFfp, recordSize - VVR_BASE_SIZE, SEEK_CUR);
  531.        usedBytes += recordSize;
  532.        break;
  533.  
  534.       /************************************************************************
  535.       * Attribute descriptor record
  536.       ************************************************************************/
  537.  
  538.       case ADR_:
  539.        ADRcount++;
  540.  
  541.        getint32 (CDFfp, int4);
  542.        if (level == FULL_) fprintf (OUTfp, "ADRnext: %ld\n", int4);
  543.  
  544.        getint32 (CDFfp, int4);
  545.        if (level == FULL_) fprintf (OUTfp, "AEDRhead: %ld\n", int4);
  546.  
  547.        getint32 (CDFfp, int4);
  548.        if (level == FULL_) fprintf (OUTfp, "scope: %ld\n", int4);
  549.  
  550.        getint32 (CDFfp, int4);
  551.        if (level == FULL_) fprintf (OUTfp, "attrNum: %ld\n", int4);
  552.  
  553.        getint32 (CDFfp, int4);
  554.        if (level == FULL_) fprintf (OUTfp, "numEntries: %ld\n", int4);
  555.  
  556.        getint32 (CDFfp, int4);
  557.        if (level == FULL_) fprintf (OUTfp, "maxEntry: %ld\n", int4);
  558.  
  559.        getint32 (CDFfp, int4);
  560.        if (level == FULL_) fprintf (OUTfp, "rfuA: %ld\n", int4);
  561.  
  562.        getint32 (CDFfp, int4);
  563.        if (level == FULL_) fprintf (OUTfp, "rfuB: %ld\n", int4);
  564.  
  565.        getint32 (CDFfp, int4);
  566.        if (level == FULL_) fprintf (OUTfp, "rfuC: %ld\n", int4);
  567.  
  568.        getint32 (CDFfp, int4);
  569.        if (level == FULL_) fprintf (OUTfp, "rfuD: %ld\n", int4);
  570.  
  571.        getint32 (CDFfp, int4);
  572.        if (level == FULL_) fprintf (OUTfp, "rfuE: %ld\n", int4);
  573.  
  574.        Read (attrName, CDF_ATTR_NAME_LEN, 1, CDFfp);
  575.        if (level == FULL_) fprintf (OUTfp, "attrName: %s\n", attrName);
  576.  
  577.        usedBytes += recordSize;
  578.        break;
  579.  
  580.       /************************************************************************
  581.       * Attribute entry descriptor record
  582.       ************************************************************************/
  583.  
  584.       case AEDR_:
  585.        AEDRcount++;
  586.  
  587.        getint32 (CDFfp, int4);
  588.        if (level == FULL_) fprintf (OUTfp, "AEDRnext: %ld\n", int4);
  589.  
  590.        getint32 (CDFfp, int4);
  591.        if (level == FULL_) fprintf (OUTfp, "attrNum: %ld\n", int4);
  592.  
  593.        getint32 (CDFfp, dataType);
  594.        if (level == FULL_) fprintf (OUTfp, "dataType: %ld\n", dataType);
  595.  
  596.        getint32 (CDFfp, int4);
  597.        if (level == FULL_) fprintf (OUTfp, "entryNum: %ld\n", int4);
  598.  
  599.        getint32 (CDFfp, numElements);
  600.        if (level == FULL_) fprintf (OUTfp, "numElements: %ld\n",
  601.                     numElements);
  602.  
  603.        getint32 (CDFfp, int4);
  604.        if (level == FULL_) fprintf (OUTfp, "rfuA: %ld\n", int4);
  605.  
  606.        getint32 (CDFfp, int4);
  607.        if (level == FULL_) fprintf (OUTfp, "rfuB: %ld\n", int4);
  608.  
  609.        getint32 (CDFfp, int4);
  610.        if (level == FULL_) fprintf (OUTfp, "rfuC: %ld\n", int4);
  611.  
  612.        getint32 (CDFfp, int4);
  613.        if (level == FULL_) fprintf (OUTfp, "rfuD: %ld\n", int4);
  614.  
  615.        getint32 (CDFfp, int4);
  616.        if (level == FULL_) fprintf (OUTfp, "rfuE: %ld\n", int4);
  617.  
  618.        nBytes = numElements * ElemSize(dataType);
  619.        valuePtr = (void *) malloc (nBytes);
  620.        CHECKmalloc (valuePtr);
  621.        Read (valuePtr, nBytes, 1, CDFfp);
  622.  
  623.        DecodeBuffer (encoding, dataType, numElements, valuePtr);
  624.  
  625.        strcpy (string, "value: ");
  626.  
  627.        if (dataType == CDF_CHAR || dataType == CDF_UCHAR)
  628.          strcat (string, "\"");
  629.  
  630.        for (i = 0; i < numElements; i++) {
  631.           switch (dataType) {
  632.           case CDF_INT1:
  633.           case CDF_BYTE:
  634.               sprintf (string1, "%d ",
  635.                    *((Schar *) valuePtr + i));
  636.               break;
  637.           case CDF_UINT1:
  638.               sprintf (string1, "%u ",
  639.                    *((Uchar *) valuePtr + i));
  640.               break;
  641.           case CDF_CHAR:
  642.           case CDF_UCHAR:
  643.               sprintf (string1, "%c", *((char *) valuePtr + i));
  644.               break;
  645.           case CDF_INT2:
  646.               sprintf (string1, "%d ", *((short *) valuePtr + i));
  647.               break;
  648.           case CDF_UINT2:
  649.               sprintf (string1, "%u ",
  650.                    *((unsigned short *) valuePtr + i));
  651.               break;
  652.           case CDF_INT4:
  653.               sprintf (string1, "%ld ", *((long *) valuePtr + i));
  654.               break;
  655.           case CDF_UINT4:
  656.               sprintf (string1, "%lu ",
  657.                    *((unsigned long *) valuePtr + i));
  658.               break;
  659.           case CDF_REAL4:
  660.           case CDF_FLOAT:
  661.               sprintf (string1, "%f ", *((float *) valuePtr + i));
  662.               break;
  663.           case CDF_REAL8:
  664.           case CDF_DOUBLE:
  665.               sprintf (string1, "%f ", *((double *) valuePtr + i));
  666.               break;
  667.           case CDF_EPOCH:
  668.               ep.tSince0 = *((double *) valuePtr + i);
  669.               strcpy (string1, epochString(&ep));
  670.               strcat (string1, " ");
  671.               break;
  672.           default:
  673.               strcpy (string1, "?");
  674.               break;
  675.           }
  676.  
  677.           if (strlen(string) + strlen(string1) > 75) {
  678.         strcat (string, "...");
  679.         break;
  680.           }
  681.           else
  682.         strcat (string, string1);
  683.        }
  684.  
  685.        if (dataType == CDF_CHAR ||
  686.            dataType == CDF_UCHAR) strcat (string, "\"");
  687.        if (level == FULL_) fprintf (OUTfp, "%s\n", string);
  688.  
  689.        free (valuePtr);
  690.  
  691.        usedBytes += recordSize;
  692.        break;
  693.  
  694.       /************************************************************************
  695.       * Illegal record type.
  696.       ************************************************************************/
  697.       default:
  698.        Close (CDFfp);
  699.        fclose (OUTfp);
  700.        DisplayStats (OUTfp);
  701.        Exit;
  702.     }
  703. }
  704. }
  705.  
  706.  
  707. /******************************************************************************
  708. * DisplayStats.  Display statistics of the dump.
  709. ******************************************************************************/
  710.  
  711. static void DisplayStats (OUTfp)
  712. FILE *OUTfp;
  713. {
  714. float totalBytes = usedBytes + wastedBytes;
  715. fprintf (OUTfp, "\n\n  Used bytes: %9ld (%.1f%%).\n",
  716.      usedBytes, 100.0 * usedBytes/totalBytes);
  717. fprintf (OUTfp, "Unused bytes: %9ld (%.1f%%).\n",
  718.      wastedBytes, 100.0 * wastedBytes/totalBytes);
  719. fprintf (OUTfp, "\n   CDR count: %9ld\n", CDRcount);
  720. fprintf (OUTfp, "   GDR count: %9ld\n", GDRcount);
  721. fprintf (OUTfp, "   ADR count: %9ld\n", ADRcount);
  722. fprintf (OUTfp, "  AEDR count: %9ld\n", AEDRcount);
  723. fprintf (OUTfp, "   VDR count: %9ld\n", VDRcount);
  724. fprintf (OUTfp, "   VXR count: %9ld\n", VXRcount);
  725. fprintf (OUTfp, "   VVR count: %9ld\n", VVRcount);
  726. fprintf (OUTfp, "UNUSED count: %9ld\n\n\n", UNUSEDcount);
  727. return;
  728. }
  729.